package org.jetnuke.dao.generic;

import org.apache.log4j.Logger;

import net.jforum.dao.AttachmentDAO;
import net.jforum.dao.BookmarkDAO;
import net.jforum.dao.CategoryDAO;
import net.jforum.dao.ConfigDAO;
import net.jforum.dao.ForumDAO;
import net.jforum.dao.GroupDAO;
import net.jforum.dao.KarmaDAO;
import net.jforum.dao.ModerationDAO;
import net.jforum.dao.PostDAO;
import net.jforum.dao.PrivateMessageDAO;
import net.jforum.dao.RankingDAO;
import net.jforum.dao.ScheduledSearchIndexerDAO;
import net.jforum.dao.SearchDAO;
import net.jforum.dao.SearchIndexerDAO;
import net.jforum.dao.SmilieDAO;
import net.jforum.dao.SummaryDAO;
import net.jforum.dao.ThemeDAO;
import net.jforum.dao.TopicDAO;
import net.jforum.dao.TreeGroupDAO;
import net.jforum.dao.UserDAO;
import net.jforum.dao.UserSessionDAO;
import net.jforum.dao.security.GroupSecurityDAO;

import org.jetnuke.dao.AutoNewsDAO;
import org.jetnuke.dao.BannerClientDAO;
import org.jetnuke.dao.BannerDAO;
import org.jetnuke.dao.BlockDAO;
import org.jetnuke.dao.BlogCategoryDAO;
import org.jetnuke.dao.BlogCommentDAO;
import org.jetnuke.dao.BlogHitsDAO;
import org.jetnuke.dao.BlogPostDAO;
import org.jetnuke.dao.BlogSettingsDAO;
import org.jetnuke.dao.BlogUserSettingsDAO;
import org.jetnuke.dao.BrowserCounterDAO;
import org.jetnuke.dao.CalendarEventDAO;
import org.jetnuke.dao.CalendarEventTypeDAO;
import org.jetnuke.dao.CensoreDAO;
import org.jetnuke.dao.CommentDAO;
import org.jetnuke.dao.DownloadCategoriesDAO;
import org.jetnuke.dao.DownloadDownloadDAO;
import org.jetnuke.dao.DownloadEditorialDAO;
import org.jetnuke.dao.DownloadModRequestDAO;
import org.jetnuke.dao.DownloadNewDownloadDAO;
import org.jetnuke.dao.DownloadVoteDataDAO;
import org.jetnuke.dao.EncyclopediaDAO;
import org.jetnuke.dao.EncyclopediaTextDAO;
import org.jetnuke.dao.FaqAnswerDAO;
import org.jetnuke.dao.FaqCategoriesDAO;
import org.jetnuke.dao.HeadLinesDAO;
import org.jetnuke.dao.LinkCategoriesDAO;
import org.jetnuke.dao.LinkEditorialDAO;
import org.jetnuke.dao.LinkLinkDAO;
import org.jetnuke.dao.LinkModRequestDAO;
import org.jetnuke.dao.LinkNewLinkDAO;
import org.jetnuke.dao.LinkVoteDataDAO;
import org.jetnuke.dao.MainConfigDAO;
import org.jetnuke.dao.MessageDAO;
import org.jetnuke.dao.ModuleDAO;
import org.jetnuke.dao.OsCounterDAO;
import org.jetnuke.dao.PagesCatDAO;
import org.jetnuke.dao.PagesDAO;
import org.jetnuke.dao.PictureAlbumDAO;
import org.jetnuke.dao.PictureCommentDAO;
import org.jetnuke.dao.PictureDAO;
import org.jetnuke.dao.PictureSettingsDAO;
import org.jetnuke.dao.PictureUserSettingsDAO;
import org.jetnuke.dao.PictureVoteDAO;
import org.jetnuke.dao.PollCheckDAO;
import org.jetnuke.dao.PollDAO;
import org.jetnuke.dao.PollDataDAO;
import org.jetnuke.dao.QueueDAO;
import org.jetnuke.dao.RefererDAO;
import org.jetnuke.dao.ReviewsAddDAO;
import org.jetnuke.dao.ReviewsCommentDAO;
import org.jetnuke.dao.ReviewsDAO;
import org.jetnuke.dao.SeccontDAO;
import org.jetnuke.dao.SectionsDAO;
import org.jetnuke.dao.StoriesCatDAO;
import org.jetnuke.dao.StoriesDAO;
import org.jetnuke.dao.StoryCheckDAO;
import org.jetnuke.dao.TopicsDAO;

public class DataAccessDriver extends org.jetnuke.dao.DataAccessDriver {
	/**
	 * Logger for this class
	 */
	private static final Logger logger = Logger
			.getLogger(DataAccessDriver.class);

	protected static net.jforum.dao.DataAccessDriver delegate = null;// new
																		// net.jforum.drivers.generic.DataAccessDriver();

	private static StoriesDAO storiesModel = new GenericStoriesDAO();
	private static TopicsDAO topicsModel = new GenericTopicsDAO();
	private static StoriesCatDAO storiesCatModel = new GenericStoriesCatDAO();
	private static PagesCatDAO pagesCatModel = new GenericPagesCatDAO();
	private static SectionsDAO sectionsModel = new GenericSectionsDAO();
	private static ReviewsDAO reviewsModel = new GenericReviewsDAO();
	private static PagesDAO pagesModel = new GenericPagesDAO();
	private static EncyclopediaDAO encyclopediaModel = new GenericEncyclopediaDAO();
	private static EncyclopediaTextDAO encyTextModel = new GenericEncyclopediaTextDAO();
	private static SeccontDAO seccontModel = new GenericSeccontDAO();

	private static DownloadCategoriesDAO downloadCategoriesModel = new GenericDownloadCategoriesDAO();
	private static DownloadDownloadDAO downdownModel = new GenericDownloadDownloadDAO();
	private static DownloadNewDownloadDAO downNewDownModel = new GenericDownloadNewDownloadDAO();
	private static DownloadVoteDataDAO downVoteData = new GenericDownloadVoteDataDAO();
	private static DownloadEditorialDAO downEditorial = new GenericDownloadEditorialDAO();
	private static DownloadModRequestDAO downModRequest = new GenericDownloadModRequestDAO();

	private static LinkCategoriesDAO linkCategoriesModel = new GenericLinkCategoriesDAO();
	private static LinkLinkDAO linkModel = new GenericLinkLinkDAO();
	private static LinkNewLinkDAO linkNewLinkModel = new GenericLinkNewLinkDAO();
	private static LinkVoteDataDAO linkVoteData = new GenericLinkVoteDataDAO();
	private static LinkEditorialDAO linkEditorial = new GenericLinkEditorialDAO();
	private static LinkModRequestDAO linkModRequest = new GenericLinkModRequestDAO();

	private static FaqAnswerDAO faqAnswerModel = new GenericFaqAnswerDAO();
	private static FaqCategoriesDAO faqCategoriesModel = new GenericFaqCategoriesDAO();
	private static AutoNewsDAO autoNewsModel = new GenericAutoNewsDAO();
	private static CommentDAO commentModel = new GenericCommentDAO();
	private static BlockDAO blockModel = new GenericBlockDAO();
	private static QueueDAO queueModel = new GenericQueueDAO();
	private static ModuleDAO modulesModel = new GenericModuleDAO();
	private static RefererDAO refererModel = new GenericRefererDAO();
	private static MessageDAO messageModel = new GenericMessageDAO();
	private static BannerClientDAO bannerClientModel = new GenericBannerClientDAO();
	private static BannerDAO bannerModel = new GenericBannerDAO();
	private static StoryCheckDAO storyCheckModel = new GenericStoryCheckDAO();
	private static PollDAO pollModel = new GenericPollDAO();
	private static PollDataDAO pollDataModel = new GenericPollDataDAO();
	private static PollCheckDAO pollCheckModel = new GenericPollCheckDAO();
	private static BrowserCounterDAO browserCounterModel = new GenericBrowserCounterDAO();
	private static CensoreDAO censoreModel = new GenericCensoreDAO();
	private static OsCounterDAO osCounterModel = new GenericOsCounterDAO();
	private static MainConfigDAO mainConfigModel = new GenericMainConfigDAO();

	private static ReviewsCommentDAO reviewsCommentModel = new GenericReviewsCommentDAO();
	private static ReviewsAddDAO reviewsAddModel = new GenericReviewsAddDAO();
	private static HeadLinesDAO headLinesModel = new GenericHeadLinesDAO();

	private static BlogUserSettingsDAO blogUserSettingsModel = new GenericBlogUserSettingsDAO();
	private static BlogPostDAO blogPostModel = new GenericBlogPostDAO();
	private static BlogCategoryDAO blogCategoryModel = new GenericBlogCategoryDAO();
	private static BlogCommentDAO blogCommentModel = new GenericBlogCommentDAO();
	private static BlogSettingsDAO blogSettingsModel = new GenericBlogSettingsDAO();
	private static PictureDAO pictureModel = new GenericPictureDAO();
	// private static PictureCategoryDAO pictureCategoryModel=new
	// GenericPictureCategoryDAO();
	private static PictureAlbumDAO pictureAlbumModel = new GenericPictureAlbumDAO();
	private static PictureUserSettingsDAO pictureUserSettingsModel = new GenericPictureUserSettingsDAO();
	private static PictureSettingsDAO pictureSettingsModel = new GenericPictureSettingsDAO();
	private static BlogHitsDAO blogHitsModel = new GenericBlogHitsDAO();

	private static PictureVoteDAO pictureVoteModel = new GenericPictureVoteDAO();

	private static PictureCommentDAO pictureCommentModel = new GenericPictureCommentDAO();
	private static CalendarEventDAO calendarEventModel = new GenericCalendarEventDAO();
	private static CalendarEventTypeDAO calendarEventTypeModel = new GenericCalendarEventTypeDAO();

	public BlogCategoryDAO newBlogCategoryDAO() {
		return blogCategoryModel;
	}

	public BlogPostDAO newBlogPostDAO() {
		return blogPostModel;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.jetnuke.model.DataAccessDriver#newStoriesModel()
	 */
	public StoriesDAO newStoriesDAO() {
		return storiesModel;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.jetnuke.model.DataAccessDriver#newTopicsModel()
	 */
	public TopicsDAO newTopicsDAO() {
		return topicsModel;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.jetnuke.model.DataAccessDriver#newStoriesCatModel()
	 */
	public StoriesCatDAO newStoriesCatDAO() {
		return storiesCatModel;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.jetnuke.model.DataAccessDriver#newPagesCatModel()
	 */
	public PagesCatDAO newPagesCatDAO() {

		return pagesCatModel;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.jetnuke.model.DataAccessDriver#newSectionsModel()
	 */
	public SectionsDAO newSectionsDAO() {
		return sectionsModel;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.jetnuke.model.DataAccessDriver#newReviewsModel()
	 */
	public ReviewsDAO newReviewsDAO() {
		return reviewsModel;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.jetnuke.model.DataAccessDriver#newPagesModel()
	 */
	public PagesDAO newPagesDAO() {

		return pagesModel;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.jetnuke.model.DataAccessDriver#newDownloadCategoriesModel()
	 */
	public DownloadCategoriesDAO newDownloadCategoriesDAO() {

		return downloadCategoriesModel;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.jetnuke.model.DataAccessDriver#newEncyclopediaModel()
	 */
	public EncyclopediaDAO newEncyclopediaDAO() {

		return encyclopediaModel;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.jetnuke.model.DataAccessDriver#newSeccontModel()
	 */
	public SeccontDAO newSeccontDAO() {

		return seccontModel;
	}

	public DownloadDownloadDAO newDownloadDownloadDAO() {

		return downdownModel;
	}

	public DownloadNewDownloadDAO newDownloadNewDownloadDAO() {

		return downNewDownModel;
	}

	public DownloadVoteDataDAO newDownloadVoteDAO() {
		return downVoteData;
	}

	public DownloadModRequestDAO newDownloadModRequestDAO() {
		return downModRequest;
	}

	public DownloadEditorialDAO newDownloadEditorialDAO() {
		return downEditorial;
	}

	public LinkLinkDAO newLinkLinkDAO() {

		return linkModel;
	}

	public LinkNewLinkDAO newLinkNewLinkDAO() {

		return linkNewLinkModel;
	}

	public LinkVoteDataDAO newLinkVoteDataDAO() {
		return linkVoteData;
	}

	public LinkModRequestDAO newLinkModRequestDAO() {
		return linkModRequest;
	}

	public LinkEditorialDAO newLinkEditorialDAO() {
		return linkEditorial;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.jetnuke.model.DataAccessDriver#newLinkCategoriesModel()
	 */
	public LinkCategoriesDAO newLinkCategoriesDAO() {
		return linkCategoriesModel;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.jetnuke.model.DataAccessDriver#newFaqAnswerModel()
	 */
	public FaqAnswerDAO newFaqAnswerDAO() {
		return faqAnswerModel;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.jetnuke.model.DataAccessDriver#newFaqCatModel()
	 */
	public FaqCategoriesDAO newFaqCatDAO() {

		return faqCategoriesModel;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.jetnuke.model.DataAccessDriver#newEncyclopediaTextModel()
	 */
	public EncyclopediaTextDAO newEncyclopediaTextDAO() {

		return encyTextModel;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.jetnuke.model.DataAccessDriver#newAutoNewsModel()
	 */
	public AutoNewsDAO newAutoNewsDAO() {
		return autoNewsModel;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.jetnuke.model.DataAccessDriver#newCommentModel()
	 */
	public CommentDAO newCommentDAO() {
		return commentModel;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.jetnuke.model.DataAccessDriver#newBlockModel()
	 */
	public BlockDAO newBlockDAO() {
		return blockModel;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.jetnuke.model.DataAccessDriver#newQueueModel()
	 */
	public QueueDAO newQueueDAO() {

		return queueModel;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.jetnuke.model.DataAccessDriver#newModulesModel()
	 */
	public ModuleDAO newModulesDAO() {

		return modulesModel;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.jetnuke.model.DataAccessDriver#newRefererModel()
	 */
	public RefererDAO newRefererDAO() {
		return refererModel;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.jetnuke.model.DataAccessDriver#newMessageModel()
	 */
	public MessageDAO newMessageDAO() {
		return messageModel;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.jetnuke.model.DataAccessDriver#newBannerModel()
	 */
	public BannerDAO newBannerJDAO() {
		return bannerModel;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.jetnuke.model.DataAccessDriver#newBannerClientModel()
	 */
	public BannerClientDAO newBannerClientDAO() {
		return bannerClientModel;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.jetnuke.model.DataAccessDriver#newStoryCheckModel()
	 */
	public StoryCheckDAO newStoryCheckDAO() {
		return storyCheckModel;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.jetnuke.model.DataAccessDriver#newPollModel()
	 */
	public PollDAO newPollJDAO() {
		return pollModel;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.jetnuke.model.DataAccessDriver#newPollDataModel()
	 */
	public PollDataDAO newPollDataDAO() {
		return pollDataModel;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.jetnuke.model.DataAccessDriver#newPollCheckModel()
	 */
	public PollCheckDAO newPollCheckDAO() {

		return pollCheckModel;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.jetnuke.model.DataAccessDriver#newCensoreModel()
	 */
	public CensoreDAO newCensoreDAO() {
		return censoreModel;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.jetnuke.model.DataAccessDriver#newBrowserCounterModel()
	 */
	public BrowserCounterDAO newBrowserCounterDAO() {
		return browserCounterModel;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.jetnuke.model.DataAccessDriver#newOsCounterModel()
	 */
	public OsCounterDAO newOsCounterDAO() {

		return osCounterModel;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.jetnuke.model.DataAccessDriver#newMainConfigModel()
	 */
	public MainConfigDAO newMainConfigDAO() {

		return mainConfigModel;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.jetnuke.model.DataAccessDriver#newReviewsAddModel()
	 */
	public ReviewsAddDAO newReviewsAddDAO() {
		return reviewsAddModel;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.jetnuke.model.DataAccessDriver#newReviewsCommentModel()
	 */
	public ReviewsCommentDAO newReviewsCommentDAO() {
		return reviewsCommentModel;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.jetnuke.model.DataAccessDriver#newHeadLinesModel()
	 */
	public HeadLinesDAO newHeadLinesDAO() {
		return headLinesModel;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see net.jforum.model.DataAccessDriver#newForumModel()
	 */
	public ForumDAO newForumDAO() {
		if (logger.isDebugEnabled()) {
			logger.debug("newForumDAO() - start"); //$NON-NLS-1$
		}

		ForumDAO returnForumDAO = delegate.newForumDAO();
		if (logger.isDebugEnabled()) {
			logger.debug("newForumDAO() - end"); //$NON-NLS-1$
		}
		return returnForumDAO;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see net.jforum.model.DataAccessDriver#newGroupModel()
	 */
	public GroupDAO newGroupDAO() {
		if (logger.isDebugEnabled()) {
			logger.debug("newGroupDAO() - start"); //$NON-NLS-1$
		}

		GroupDAO returnGroupDAO = delegate.newGroupDAO();
		if (logger.isDebugEnabled()) {
			logger.debug("newGroupDAO() - end"); //$NON-NLS-1$
		}
		return returnGroupDAO;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see net.jforum.model.DataAccessDriver#newPostModel()
	 */
	public PostDAO newPostDAO() {
		if (logger.isDebugEnabled()) {
			logger.debug("newPostDAO() - start"); //$NON-NLS-1$
		}

		PostDAO returnPostDAO = delegate.newPostDAO();
		if (logger.isDebugEnabled()) {
			logger.debug("newPostDAO() - end"); //$NON-NLS-1$
		}
		return returnPostDAO;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see net.jforum.model.DataAccessDriver#newRankingModel()
	 */
	public RankingDAO newRankingModel() {
		if (logger.isDebugEnabled()) {
			logger.debug("newRankingModel() - start"); //$NON-NLS-1$
		}

		RankingDAO returnRankingDAO = delegate.newRankingDAO();
		if (logger.isDebugEnabled()) {
			logger.debug("newRankingModel() - end"); //$NON-NLS-1$
		}
		return returnRankingDAO;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see net.jforum.model.DataAccessDriver#newTopicModel()
	 */
	public TopicDAO newTopicDAO() {
		if (logger.isDebugEnabled()) {
			logger.debug("newTopicDAO() - start"); //$NON-NLS-1$
		}

		TopicDAO returnTopicDAO = delegate.newTopicDAO();
		if (logger.isDebugEnabled()) {
			logger.debug("newTopicDAO() - end"); //$NON-NLS-1$
		}
		return returnTopicDAO;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see net.jforum.model.DataAccessDriver#newUserModel()
	 */
	public UserDAO newUserDAO() {
		if (logger.isDebugEnabled()) {
			logger.debug("newUserDAO() - start"); //$NON-NLS-1$
		}

		UserDAO returnUserDAO = delegate.newUserDAO();
		if (logger.isDebugEnabled()) {
			logger.debug("newUserDAO() - end"); //$NON-NLS-1$
		}
		return returnUserDAO;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see net.jforum.model.DataAccessDriver#newCategoryModel()
	 */
	public CategoryDAO newCategoryDAO() {
		if (logger.isDebugEnabled()) {
			logger.debug("newCategoryDAO() - start"); //$NON-NLS-1$
		}

		CategoryDAO returnCategoryDAO = delegate.newCategoryDAO();
		if (logger.isDebugEnabled()) {
			logger.debug("newCategoryDAO() - end"); //$NON-NLS-1$
		}
		return returnCategoryDAO;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see net.jforum.model.DataAccessDriver#newTreeGroupModel()
	 */
	public TreeGroupDAO newTreeGroupModel() {
		if (logger.isDebugEnabled()) {
			logger.debug("newTreeGroupModel() - start"); //$NON-NLS-1$
		}

		TreeGroupDAO returnTreeGroupDAO = delegate.newTreeGroupDAO();
		if (logger.isDebugEnabled()) {
			logger.debug("newTreeGroupModel() - end"); //$NON-NLS-1$
		}
		return returnTreeGroupDAO;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see net.jforum.model.DataAccessDriver#newSmilieModel()
	 */
	public SmilieDAO newSmilieDAO() {
		if (logger.isDebugEnabled()) {
			logger.debug("newSmilieDAO() - start"); //$NON-NLS-1$
		}

		SmilieDAO returnSmilieDAO = delegate.newSmilieDAO();
		if (logger.isDebugEnabled()) {
			logger.debug("newSmilieDAO() - end"); //$NON-NLS-1$
		}
		return returnSmilieDAO;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see net.jforum.model.DataAccessDriver#newSearchModel()
	 */
	public SearchDAO newSearchDAO() {
		if (logger.isDebugEnabled()) {
			logger.debug("newSearchDAO() - start"); //$NON-NLS-1$
		}

		SearchDAO returnSearchDAO = delegate.newSearchDAO();
		if (logger.isDebugEnabled()) {
			logger.debug("newSearchDAO() - end"); //$NON-NLS-1$
		}
		return returnSearchDAO;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see net.jforum.model.DataAccessDriver#newSearchIndexerModel()
	 */
	public SearchIndexerDAO newSearchIndexerDAO() {
		if (logger.isDebugEnabled()) {
			logger.debug("newSearchIndexerDAO() - start"); //$NON-NLS-1$
		}

		SearchIndexerDAO returnSearchIndexerDAO = delegate
				.newSearchIndexerDAO();
		if (logger.isDebugEnabled()) {
			logger.debug("newSearchIndexerDAO() - end"); //$NON-NLS-1$
		}
		return returnSearchIndexerDAO;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see net.jforum.model.DataAccessDriver#newGroupSecurityModel()
	 */
	public GroupSecurityDAO newGroupSecurityDAO() {
		if (logger.isDebugEnabled()) {
			logger.debug("newGroupSecurityDAO() - start"); //$NON-NLS-1$
		}

		GroupSecurityDAO returnGroupSecurityDAO = delegate
				.newGroupSecurityDAO();
		if (logger.isDebugEnabled()) {
			logger.debug("newGroupSecurityDAO() - end"); //$NON-NLS-1$
		}
		return returnGroupSecurityDAO;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see net.jforum.model.DataAccessDriver#newPrivateMessageModel()
	 */
	public PrivateMessageDAO newPrivateMessageDAO() {
		if (logger.isDebugEnabled()) {
			logger.debug("newPrivateMessageDAO() - start"); //$NON-NLS-1$
		}

		PrivateMessageDAO returnPrivateMessageDAO = delegate
				.newPrivateMessageDAO();
		if (logger.isDebugEnabled()) {
			logger.debug("newPrivateMessageDAO() - end"); //$NON-NLS-1$
		}
		return returnPrivateMessageDAO;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see net.jforum.model.DataAccessDriver#newUserSessionModel()
	 */
	public UserSessionDAO newUserSessionDAO() {
		if (logger.isDebugEnabled()) {
			logger.debug("newUserSessionDAO() - start"); //$NON-NLS-1$
		}

		UserSessionDAO returnUserSessionDAO = delegate.newUserSessionDAO();
		if (logger.isDebugEnabled()) {
			logger.debug("newUserSessionDAO() - end"); //$NON-NLS-1$
		}
		return returnUserSessionDAO;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see net.jforum.model.DataAccessDriver#newConfigModel()
	 */
	public ConfigDAO newConfigDAO() {
		if (logger.isDebugEnabled()) {
			logger.debug("newConfigDAO() - start"); //$NON-NLS-1$
		}

		ConfigDAO returnConfigDAO = delegate.newConfigDAO();
		if (logger.isDebugEnabled()) {
			logger.debug("newConfigDAO() - end"); //$NON-NLS-1$
		}
		return returnConfigDAO;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see net.jforum.model.DataAccessDriver#newKarmaModel()
	 */
	public KarmaDAO newKarmaDAO() {
		if (logger.isDebugEnabled()) {
			logger.debug("newKarmaDAO() - start"); //$NON-NLS-1$
		}

		KarmaDAO returnKarmaDAO = delegate.newKarmaDAO();
		if (logger.isDebugEnabled()) {
			logger.debug("newKarmaDAO() - end"); //$NON-NLS-1$
		}
		return returnKarmaDAO;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see net.jforum.model.DataAccessDriver#newBookmarkModel()
	 */
	public BookmarkDAO newBookmarkDAO() {
		if (logger.isDebugEnabled()) {
			logger.debug("newBookmarkDAO() - start"); //$NON-NLS-1$
		}

		BookmarkDAO returnBookmarkDAO = delegate.newBookmarkDAO();
		if (logger.isDebugEnabled()) {
			logger.debug("newBookmarkDAO() - end"); //$NON-NLS-1$
		}
		return returnBookmarkDAO;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see net.jforum.model.DataAccessDriver#newAttachmentModel()
	 */
	public AttachmentDAO newAttachmentDAO() {
		if (logger.isDebugEnabled()) {
			logger.debug("newAttachmentDAO() - start"); //$NON-NLS-1$
		}

		AttachmentDAO returnAttachmentDAO = delegate.newAttachmentDAO();
		if (logger.isDebugEnabled()) {
			logger.debug("newAttachmentDAO() - end"); //$NON-NLS-1$
		}
		return returnAttachmentDAO;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see net.jforum.model.DataAccessDriver#newModerationModel()
	 */
	public ModerationDAO newModerationDAO() {
		if (logger.isDebugEnabled()) {
			logger.debug("newModerationDAO() - start"); //$NON-NLS-1$
		}

		ModerationDAO returnModerationDAO = delegate.newModerationDAO();
		if (logger.isDebugEnabled()) {
			logger.debug("newModerationDAO() - end"); //$NON-NLS-1$
		}
		return returnModerationDAO;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see net.jforum.model.DataAccessDriver#newThemeModel()
	 */
	public ThemeDAO newThemeDAO() {
		if (logger.isDebugEnabled()) {
			logger.debug("newThemeDAO() - start"); //$NON-NLS-1$
		}

		ThemeDAO returnThemeDAO = delegate.newThemeDAO();
		if (logger.isDebugEnabled()) {
			logger.debug("newThemeDAO() - end"); //$NON-NLS-1$
		}
		return returnThemeDAO;
	}

	public BlogUserSettingsDAO newBlogUserSettingsDAO() {
		return blogUserSettingsModel;
	}

	public BlogCommentDAO newBlogCommentDAO() {

		return blogCommentModel;
	}

	public BlogSettingsDAO newBlogSettingsDAO() {
		return blogSettingsModel;
	}

	public BlogHitsDAO newBlogHitsDAO() {

		return blogHitsModel;
	}

	public PictureDAO newPictureDAO() {

		return pictureModel;
	}

	// public PictureCategoryDAO newPictureCategoryDAO() {
	// return pictureCategoryModel;
	// }
	public PictureAlbumDAO newPictureAlbumDAO() {
		return pictureAlbumModel;
	}

	public PictureUserSettingsDAO newPictureUserSettingsDAO() {
		return pictureUserSettingsModel;
	}

	public PictureSettingsDAO newPictureSettingsDAO() {
		return pictureSettingsModel;
	}

	public PictureCommentDAO newPictureCommentDAO() {

		return pictureCommentModel;
	}

	public PictureVoteDAO newPictureVoteDAO() {
		return pictureVoteModel;
	}

	public BannerDAO newJBannerDAO() {

		return bannerModel;
	}

	public PollDAO newJPollDAO() {

		return pollModel;
	}

	public net.jforum.dao.PollDAO newPollDAO() {
		if (logger.isDebugEnabled()) {
			logger.debug("newPollDAO() - start"); //$NON-NLS-1$
		}

		net.jforum.dao.PollDAO returnPollDAO = delegate.newPollDAO();
		if (logger.isDebugEnabled()) {
			logger.debug("newPollDAO() - end"); //$NON-NLS-1$
		}
		return returnPollDAO;
	}

	public RankingDAO newRankingDAO() {
		if (logger.isDebugEnabled()) {
			logger.debug("newRankingDAO() - start"); //$NON-NLS-1$
		}

		RankingDAO returnRankingDAO = delegate.newRankingDAO();
		if (logger.isDebugEnabled()) {
			logger.debug("newRankingDAO() - end"); //$NON-NLS-1$
		}
		return returnRankingDAO;
	}

	public TreeGroupDAO newTreeGroupDAO() {
		if (logger.isDebugEnabled()) {
			logger.debug("newTreeGroupDAO() - start"); //$NON-NLS-1$
		}

		TreeGroupDAO returnTreeGroupDAO = delegate.newTreeGroupDAO();
		if (logger.isDebugEnabled()) {
			logger.debug("newTreeGroupDAO() - end"); //$NON-NLS-1$
		}
		return returnTreeGroupDAO;
	}

	public ScheduledSearchIndexerDAO newScheduledSearchIndexerDAO() {
		if (logger.isDebugEnabled()) {
			logger.debug("newScheduledSearchIndexerDAO() - start"); //$NON-NLS-1$
		}

		ScheduledSearchIndexerDAO returnScheduledSearchIndexerDAO = delegate
				.newScheduledSearchIndexerDAO();
		if (logger.isDebugEnabled()) {
			logger.debug("newScheduledSearchIndexerDAO() - end"); //$NON-NLS-1$
		}
		return returnScheduledSearchIndexerDAO;
	}

	public net.jforum.dao.BannerDAO newBannerDAO() {
		if (logger.isDebugEnabled()) {
			logger.debug("newBannerDAO() - start"); //$NON-NLS-1$
		}

		net.jforum.dao.BannerDAO returnBannerDAO = delegate.newBannerDAO();
		if (logger.isDebugEnabled()) {
			logger.debug("newBannerDAO() - end"); //$NON-NLS-1$
		}
		return returnBannerDAO;
	}

	public SummaryDAO newSummaryDAO() {
		if (logger.isDebugEnabled()) {
			logger.debug("newSummaryDAO() - start"); //$NON-NLS-1$
		}

		SummaryDAO returnSummaryDAO = delegate.newSummaryDAO();
		if (logger.isDebugEnabled()) {
			logger.debug("newSummaryDAO() - end"); //$NON-NLS-1$
		}
		return returnSummaryDAO;
	}

	public CalendarEventDAO newCalendarEventDAO() {
		return calendarEventModel;
	}

	public CalendarEventTypeDAO newCalendarEventTypeDAO() {
		return calendarEventTypeModel;
	}
}
